ETO Development Tools 2/ETO Development Tools 2.iso/Tools - Objects/MacApp/MacApp CD Release/MacApp 2.0.1 (Many Libraries)/Libraries/UInspector.inc1.p

Text File | 1990-10-25 | 66.6 KB | 2,495 lines | [TEXT/MPS ]

{$P}
{[a-,body+,h-,o=100,r+,rec+,t=4,u+,#+,j=20/57/1$,n-]}
{UInspector.inc1.p}
{Copyright © 1987-1990 by Apple Computer, Inc.    All rights reserved.}

{$IFC NOT qDebugTheDebugger}
{$W+}
{$R-}
{$Init-}
{$OV-}
{$ENDC}
{$IFC qNames}
{$D+}
{$ENDC}

CONST
    kInspectorWindowType = 900;
    bInternalString     = - 500;                        { used to id strings used internal to
                                                         inspector }

TYPE

    {$IFC qHasForward}
    TInspectWindow        = OBJECT;    FORWARD;
    TObjListView        = OBJECT;    FORWARD;
    TObjectView            = OBJECT;    FORWARD;
    TClassListView        = OBJECT;    FORWARD;
    {$EndC}

    TObjectList         = OBJECT (TList)                { Will just be ordered by object id }

        PROCEDURE TObjectList.IObjectList(classId: ObjClassID);

        PROCEDURE TObjectList.AddObject(theObject: TObject);

        PROCEDURE TObjectList.RemoveObject(theObject: TObject);

        PROCEDURE TObjectList.Fields(PROCEDURE DoToField(fieldName: Str255;
                                                         fieldAddr: Ptr;
                                                         fieldType: INTEGER)); OVERRIDE;

        END;

    TClassesByID        = OBJECT (TSortedList)

        PROCEDURE TClassesByID.IClassesByID;

        FUNCTION TClassesByID.Compare(item1, item2: TObject): INTEGER; OVERRIDE;

        PROCEDURE TClassesByID.Fields(PROCEDURE DoToField(fieldName: Str255;
                                                        fieldAddr: Ptr;
                                                        fieldType: INTEGER)); OVERRIDE;

        END;

    TClassesByName        = OBJECT (TSortedList)

        PROCEDURE TClassesByName.IClassesByName;

        FUNCTION TClassesByName.Compare(item1, item2: TObject): INTEGER; OVERRIDE;

        PROCEDURE TClassesByName.Fields(PROCEDURE DoToField(fieldName: Str255;
                                                        fieldAddr: Ptr;
                                                        fieldType: INTEGER)); OVERRIDE;

        END;

    TInspector            = OBJECT (TDocument)

        fClassesByID:        TClassesByID;
        fClassesByName:     TClassesByName;
        fWindowCount:        INTEGER;
        fStaggerCount:        INTEGER;

        PROCEDURE TInspector.IInspector;

        PROCEDURE TInspector.Free; OVERRIDE;

        FUNCTION TInspector.MakeWindow: TInspectWindow;

        FUNCTION TInspector.AddObjectList(classId: ObjClassID): TObjectList;

        FUNCTION TInspector.GetObjectList(classId: ObjClassID): TObjectList;

        PROCEDURE TInspector.AddObject(theObject: TObject);

        PROCEDURE TInspector.RemoveObject(theObject: TObject);

        PROCEDURE TInspector.DoSetupMenus; OVERRIDE;

        PROCEDURE TInspector.Fields(PROCEDURE DoToField(fieldName: Str255;
                                                        fieldAddr: Ptr;
                                                        fieldType: INTEGER)); OVERRIDE;

        END;

    TInspectWindow        = OBJECT (TWindow)

        fClassListView:     TClassListView;
        fObjListView:        TObjListView;
        fObjectView:        TObjectView;

        PROCEDURE TInspectWindow.IRes(itsDocument: TDocument;
                                      itsSuperView: TView;
                                      VAR itsParams: Ptr); OVERRIDE;
        PROCEDURE TInspectWindow.IInspectWindow;

        PROCEDURE TInspectWindow.Draw(area: Rect); OVERRIDE;

        PROCEDURE TInspectWindow.CloseByUser; OVERRIDE;

        PROCEDURE TInspectWindow.InsertClass(itemNo: INTEGER);

        PROCEDURE TInspectWindow.Resize(width, height: VCoordinate;
                                        invalidate: BOOLEAN); OVERRIDE;

        PROCEDURE TInspectWindow.SetNumberOfClasses(noOfClasses: INTEGER);

        PROCEDURE TInspectWindow.SetTitleForDoc(newDocTitle: Str255); OVERRIDE;

        PROCEDURE TInspectWindow.SelectObject(theObject: TObject;
                                              theType: INTEGER);

        PROCEDURE TInspectWindow.Fields(PROCEDURE DoToField(fieldName: Str255;
                                                            fieldAddr: Ptr;
                                                            fieldType: INTEGER)); OVERRIDE;

        END;

    TListView            = OBJECT (TView)

        fCurrentSelection:    INTEGER;                    { index of the current selection, if any,
                                                         otherwise 0 }
        fNumberOfItems:     INTEGER;                    { number of items currently in the list }
        fTextStyle:         TextStyle;                    { font characteristics }
        fItemHeight:        INTEGER;                    { height of each item including leading }
        fLineAscent:        INTEGER;                    { position of baseline relative to top of
                                                         line }

        PROCEDURE TListView.IRes(itsDocument: TDocument;
                                 itsSuperView: TView;
                                 VAR itsParams: Ptr); OVERRIDE;
        PROCEDURE TListView.IListView(itsDocument: TDocument;
                                      itsSuperView: TView;
                                      itsLocation: VPoint;
                                      itsSize: VPoint;
                                      itsTextStyle: TextStyle;
                                      itsNumberOfItems: INTEGER;
                                      itsHSizeDet: SizeDeterminer);

        PROCEDURE TListView.CalcMinSize(VAR minSize: VPoint); OVERRIDE;

        PROCEDURE TListView.ChangeSelection(index: INTEGER;
                                            highlight: BOOLEAN);

        PROCEDURE TListView.DoHighlightSelection(fromHL, toHL: HLState); OVERRIDE;

        FUNCTION TListView.DoMouseCommand(VAR theMouse: Point;
                                          VAR info: EventInfo;
                                          VAR hysteresis: Point): TCommand; OVERRIDE;

        PROCEDURE TListView.Draw(area: Rect); OVERRIDE;

        PROCEDURE TListView.DrawItem(itemNumber: INTEGER;
                                     basePoint: Point);

        PROCEDURE TListView.Fields(PROCEDURE DoToField(fieldName: Str255;
                                                       fieldAddr: Ptr;
                                                       fieldType: INTEGER)); OVERRIDE;

        PROCEDURE TListView.InsertItem(itemNo: INTEGER);

        PROCEDURE TListView.DeleteItem(itemNo: INTEGER);

        PROCEDURE TListView.ItemToVRect(index: INTEGER;
                                        VAR itemRect: VRect);

        PROCEDURE TListView.RevealItem(itemNumber: INTEGER);

        PROCEDURE TListView.SelectItem(itemNumber: INTEGER);

        PROCEDURE TListView.SetStyle(itsTextStyle: TextStyle);

        PROCEDURE TListView.SetNumberOfItems(numberOfItems: INTEGER);

        PROCEDURE TListView.SetPen;

        FUNCTION TListView.VPointToItem(thePoint: VPoint): INTEGER;

        END;

    TClassListView        = OBJECT (TListView)            {Upper-left view}

        fInspectWindow:     TInspectWindow;

        PROCEDURE TClassListView.IRes(itsDocument: TDocument;
                                      itsSuperView: TView;
                                      VAR itsParams: Ptr); OVERRIDE;

        PROCEDURE TClassListView.IClassListView(itsWindow: TInspectWindow;
                                                itsLocation: VPoint;
                                                itsSize: VPoint);

        PROCEDURE TClassListView.DrawItem(itemNumber: INTEGER;
                                          basePoint: Point); OVERRIDE;

        PROCEDURE TClassListView.SelectItem(itemNumber: INTEGER); OVERRIDE;

        PROCEDURE TClassListView.Fields(PROCEDURE DoToField(fieldName: Str255;
                                                            fieldAddr: Ptr;
                                                            fieldType: INTEGER)); OVERRIDE;

        END;

    TObjListView        = OBJECT (TListView)            {Upper-right view}

        fInspectWindow:     TInspectWindow;
        fObjectList:        TObjectList;

        PROCEDURE TObjListView.IRes(itsDocument: TDocument;
                                    itsSuperView: TView;
                                    VAR itsParams: Ptr); OVERRIDE;

        PROCEDURE TObjListView.IObjListView(itsWindow: TInspectWindow;
                                            itsLocation: VPoint;
                                            itsSize: VPoint);

        PROCEDURE TObjListView.InstallObjectList(theObjectList: TObjectList);

        PROCEDURE TObjListView.DrawItem(itemNumber: INTEGER;
                                        basePoint: Point); OVERRIDE;

        PROCEDURE TObjListView.SelectItem(itemNumber: INTEGER); OVERRIDE;

        PROCEDURE TObjListView.Fields(PROCEDURE DoToField(fieldName: Str255;
                                                          fieldAddr: Ptr;
                                                          fieldType: INTEGER)); OVERRIDE;

        END;

    TObjectView         = OBJECT (TListView)            {bottom view}

        fInspectWindow:     TInspectWindow;
        fObject:            TObject;
        fType:                INTEGER;
        fLockState:         BOOLEAN;

        PROCEDURE TObjectView.IRes(itsDocument: TDocument;
                                   itsSuperView: TView;
                                   VAR itsParams: Ptr); OVERRIDE;

        PROCEDURE TObjectView.IObjectView(itsWindow: TInspectWindow;
                                          itsLocation: VPoint;
                                          itsSize: VPoint);

        PROCEDURE TObjectView.InspectControlHandle(PROCEDURE
                                                   InspectField(fieldName: StringPtr;
                                                                fieldAddr: Ptr;
                                                                fieldType: INTEGER));

        PROCEDURE TObjectView.InspectGrafPtr(PROCEDURE
                                             InspectField(fieldName: StringPtr;
                                                          fieldAddr: Ptr;
                                                          fieldType: INTEGER));

        PROCEDURE TObjectView.InspectRgnHandle(PROCEDURE
                                               InspectField(fieldName: StringPtr;
                                                            fieldAddr: Ptr;
                                                            fieldType: INTEGER));

        PROCEDURE TObjectView.InspectTEHandle(PROCEDURE
                                              InspectField(fieldName: StringPtr;
                                                           fieldAddr: Ptr;
                                                           fieldType: INTEGER));

        PROCEDURE TObjectView.InspectWindowPtr(PROCEDURE
                                               InspectField(fieldName: StringPtr;
                                                            fieldAddr: Ptr;
                                                            fieldType: INTEGER));

        PROCEDURE TObjectView.InspectHandle(PROCEDURE
                                            InspectField(fieldName: StringPtr;
                                                         fieldAddr: Ptr;
                                                         fieldType: INTEGER));

        PROCEDURE TObjectView.LockObject;

        PROCEDURE TObjectView.UnlockObject;

        PROCEDURE TObjectView.ChangeSelection(index: INTEGER;
                                              highlight: BOOLEAN); OVERRIDE;

        PROCEDURE TObjectView.SelectField(index: INTEGER;
                                          inspectWindow: TInspectWindow);

        FUNCTION TObjectView.DoMouseCommand(VAR theMouse: Point;
                                            VAR info: EventInfo;
                                            VAR hysteresis: Point): TCommand; OVERRIDE;

        PROCEDURE TObjectView.Draw(area: Rect); OVERRIDE;

        PROCEDURE TObjectView.SuperViewChangedSize(delta: VPoint;
                                             invalidate: BOOLEAN); OVERRIDE;

        PROCEDURE TObjectView.Resize(width, height: VCoordinate;
                                     invalidate: BOOLEAN); OVERRIDE;

        PROCEDURE TObjectView.FirstFieldThat(FUNCTION
                                             TestField(fieldName: StringPtr;
                                                       fieldAddr: Ptr;
                                                       fieldType: INTEGER): BOOLEAN);

        PROCEDURE TObjectView.InstallObject(theObject: TObject;
                                            theObjectType: INTEGER);

        PROCEDURE TObjectView.Fields(PROCEDURE DoToField(fieldName: Str255;
                                                         fieldAddr: Ptr;
                                                         fieldType: INTEGER)); OVERRIDE;

        END;

VAR
    {$Push} {$Z+}                                        { Make the root of the inspector visible to
                                                         selected friends }
    pInspector:         TInspector;
    {$Pop}
    pInspectorStyle:    TextStyle;
    pSavedFocus:        FocusRec;

    {$IFC qTrace} {$D+} {$ENDC}                         { Turn off tracing for all Inspector code in
                                                         this file }
    {$S MAInspector}                                    { Everything goes in here }

    {---------------------------------------------------------------------------}

    {$Push}
    {$IFC qTrace}
    {$IFC qDebugTheDebugger}
    {$D++}
    {$ENDC}
    {$ENDC}

PROCEDURE AddObjectToInspector(theObject: TObject);
 {This is called from %_OBNEW when an object is created, and from
  TObject.ShallowClone when cloning an object.}

    BEGIN
    IF pInspector <> NIL THEN
        pInspector.AddObject(theObject);
    END;
{$Pop}

{---------------------------------------------------------------------------}

PROCEDURE InitUInspector;

    BEGIN
    pInspector := NIL;
    SetTextStyle(pInspectorStyle, applFont, [], 9, gRGBBlack);
    pSavedFocus.clip := NewRgn;
    FailNIL(pSavedFocus.clip);

    IF qTemplateViews THEN
        BEGIN
        { Make sure linker doesn't dead strip these }
        IF gDeadStripSuppression THEN
            BEGIN
            IF Member(TObject(NIL), TInspectWindow) THEN;
            IF Member(TObject(NIL), TClassListView) THEN;
            IF Member(TObject(NIL), TObjListView) THEN;
            IF Member(TObject(NIL), TObjectView) THEN;
            END;
        END;

    END;

{---------------------------------------------------------------------------}

PROCEDURE MakeInspector;

    VAR
        anInspector:        TInspector;
        wasAddNewObjectsToInspector: BOOLEAN;
        wasTrcEnable:        BOOLEAN;

    BEGIN
    {$IFC NOT qDebugTheDebugger}
    {$IFC qDebug}
    wasTrcEnable := TrcEnable(False);
    {$EndC}
    wasAddNewObjectsToInspector := AddNewObjectsToInspector(False);
    {$ENDC}

    { Allocate and initialize the document}
    New(anInspector);
    FailNIL(anInspector);
    anInspector.IInspector;

    {$IFC NOT qDebugTheDebugger}
    IF AddNewObjectsToInspector(wasAddNewObjectsToInspector) THEN;
    {$IFC qDebug}
    IF TrcEnable(wasTrcEnable) THEN;
    {$EndC}
    {$ENDC}
    END;

{---------------------------------------------------------------------------}

PROCEDURE MakeInspectorWindow;

    VAR
        wasAddNewObjectsToInspector: BOOLEAN;
        wasTrcEnable:        BOOLEAN;
        anInspectWindow:    TInspectWindow;

    BEGIN
    {$IFC NOT qDebugTheDebugger}
    {$IFC qDebug}
    wasTrcEnable := TrcEnable(False);
    {$EndC}
    wasAddNewObjectsToInspector := AddNewObjectsToInspector(False);
    {$ENDC}

    IF pInspector <> NIL THEN
        BEGIN
        anInspectWindow := pInspector.MakeWindow;
        anInspectWindow.Open;
        END;

    {$IFC NOT qDebugTheDebugger}
    IF AddNewObjectsToInspector(wasAddNewObjectsToInspector) THEN;
    {$IFC qDebug}
    IF TrcEnable(wasTrcEnable) THEN;
    {$EndC}
    {$ENDC}
    END;

{---------------------------------------------------------------------------}

{$Push}
{$IFC qTrace}
{$IFC qDebugTheDebugger}
{$D++}
{$ENDC}
{$ENDC}

PROCEDURE RemoveObjectFromInspector(theObject: TObject);
{Called from TObject.Free.}

    VAR
        wasAddNewObjectsToInspector: BOOLEAN;
        wasTrcEnable:        BOOLEAN;

    BEGIN
    {$IFC NOT qDebugTheDebugger}
    {$IFC qDebug}
    wasTrcEnable := TrcEnable(False);
    {$EndC}
    wasAddNewObjectsToInspector := AddNewObjectsToInspector(False);
    {$ENDC}
    IF NOT gAppDone THEN
        IF pInspector <> NIL THEN
            pInspector.RemoveObject(theObject);
    {$IFC NOT qDebugTheDebugger}
    IF AddNewObjectsToInspector(wasAddNewObjectsToInspector) THEN;
    {$IFC qDebug}
    IF TrcEnable(wasTrcEnable) THEN;
    {$EndC}
    {$ENDC}
    END;
{$Pop}

{---------------------------------------------------------------------------}

PROCEDURE TObjectList.IObjectList(classId: ObjClassID);

    BEGIN
    IList;
    SetEltTypeID(classId);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectList.AddObject(theObject: TObject);

    BEGIN
    {$IFC qDebugTheDebugger}
    IF GetClassID(theObject) <> fObjClassId THEN
        ProgramBreak('TObjectList.AddObject: Object of wrong class');
    {$ENDC}

    Insert(theObject);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectList.Fields(PROCEDURE DoToField(fieldName: Str255;
                                                 fieldAddr: Ptr;
                                                 fieldType: INTEGER)); OVERRIDE;

    BEGIN
    DoToField('TObjectList', NIL, bClass);

    INHERITED Fields(DoToField);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectList.RemoveObject(theObject: TObject);

    BEGIN
    {$IFC qDebugTheDebugger}
    IF GetClassID(theObject) <> fObjClassId THEN
        ProgramBreak('TObjectList.RemoveObject: Object of wrong class');
    {$ENDC}

    Delete(theObject);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TClassesByID.IClassesByID;

    BEGIN
    ISortedList;
    END;

{---------------------------------------------------------------------------}

FUNCTION TClassesByID.Compare(item1, item2: TObject): INTEGER; OVERRIDE;

    BEGIN
    IF TObjectList(item1).fObjClassId < TObjectList(item2).fObjClassId THEN
        Compare := kItem1LessThanItem2
    ELSE IF TObjectList(item1).fObjClassId > TObjectList(item2).fObjClassId THEN
        Compare := kItem1GreaterThanItem2
    ELSE
        Compare := kItem1EqualItem2;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TClassesByID.Fields(PROCEDURE DoToField(fieldName: Str255;
                                                fieldAddr: Ptr;
                                                fieldType: INTEGER)); OVERRIDE;
    BEGIN
    DoToField('TClassesByID', NIL, bClass);
    INHERITED Fields(DoToField);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TClassesByName.IClassesByName;

    BEGIN
    ISortedList;
    END;

{---------------------------------------------------------------------------}

FUNCTION TClassesByName.Compare(item1, item2: TObject): INTEGER; OVERRIDE;

    VAR
        string1, string2:    MAName;

    BEGIN
    GetClassNameFromID(TObjectList(item1).fObjClassId, string1);
    GetClassNameFromID(TObjectList(item2).fObjClassId, string2);
    IF string1 < string2 THEN
        Compare := kItem1LessThanItem2
    ELSE IF string1 > string2 THEN
        Compare := kItem1GreaterThanItem2
    ELSE
        Compare := kItem1EqualItem2;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TClassesByName.Fields(PROCEDURE DoToField(fieldName: Str255;
                                                fieldAddr: Ptr;
                                                fieldType: INTEGER)); OVERRIDE;
    BEGIN
    DoToField('TClassesByName', NIL, bClass);
    INHERITED Fields(DoToField);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspector.IInspector;

    VAR
        aClassesByName:     TClassesByName;
        aClassesById:        TClassesByID;

    BEGIN
    IDocument('????', '????', NOT kUsesDataFork, NOT kUsesRsrcFork, NOT kDataOpen, NOT kRsrcOpen);
    SetTitle('Inspector');

    New(aClassesByName);
    FailNIL(aClassesByName);
    aClassesByName.IClassesByName;
    aClassesByName.SetEltType('TObjectList');
    fClassesByName := aClassesByName;
    New(aClassesById);
    FailNIL(aClassesById);
    aClassesById.IClassesByID;
    aClassesById.SetEltType('TObjectList');
    fClassesByID := aClassesById;

    pInspector := SELF;

    fWindowCount := 0;
    fStaggerCount := 0;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspector.Free; OVERRIDE;

    BEGIN

    fClassesByID := TClassesByID(FreeListIfObject(fClassesByID));

    FreeIfObject(fClassesByName);
    fClassesByName := NIL;

    pInspector := NIL;

    INHERITED Free;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspector.Fields(PROCEDURE DoToField(fieldName: Str255;
                                                fieldAddr: Ptr;
                                                fieldType: INTEGER)); OVERRIDE;

    BEGIN
    DoToField('TInspector', NIL, bClass);
    DoToField('fClassesByID', @fClassesByID, bObject);
    DoToField('fClassesByName', @fClassesByName, bObject);
    DoToField('fWindowCount', @fWindowCount, bInteger);
    DoToField('fStaggerCount', @fStaggerCount, bInteger);
    INHERITED Fields(DoToField);
    END;

{---------------------------------------------------------------------------}

FUNCTION TInspector.MakeWindow: TInspectWindow;

    VAR
        anInspectWindow:    TInspectWindow;
        staggerCount:        INTEGER;
        screenRect:         Rect;

    BEGIN
    fWindowCount := fWindowCount + 1;

    IF qTemplateViews THEN
        BEGIN
        anInspectWindow := TInspectWindow(NewTemplateWindow(kInspectorWindowType, SELF));
        FailNIL(anInspectWindow);

        WITH anInspectWindow DO
            BEGIN

            fClassListView := TClassListView(FindSubView('IVW1'));
            fObjListView := TObjListView(FindSubView('IVW2'));
            fObjectView := TObjectView(FindSubView('IVW3'));

            fClassListView.fInspectWindow := anInspectWindow;
            fObjListView.fInspectWindow := anInspectWindow;
            fObjectView.fInspectWindow := anInspectWindow;

            { Use GetMaxIntersectedDevice to Locate our window. }
            IF GetMaxIntersectedDevice(screenRect) = NIL THEN;
            WITH screenRect DO
                BEGIN
                Locate(right - fWMgrWindow^.portRect.right, top + fContRgnInset.v, kDontInvalidate);

                {Adapt height of window to height of screen}
                IF bottom > 342 THEN
                    Resize(fWMgrWindow^.portRect.right, Max(252, bottom - 192), kDontInvalidate);

                END;
            END;
        END

    ELSE
        BEGIN
        New(anInspectWindow);
        FailNIL(anInspectWindow);
        anInspectWindow.IInspectWindow;
        anInspectWindow.ForceOnScreen;
        END;

    WITH anInspectWindow DO
        BEGIN
        staggerCount := fStaggerCount;
        SimpleStagger( - kStdStaggerAmount, kStdStaggerAmount, staggerCount);
        fStaggerCount := staggerCount;

        SetNumberOfClasses(fClassesByID.GetSize);

{ Installs print handler if client app is using printing }
        InstallIfPrintHandler(gPrintHandler, fObjectView);

        END;

    MakeWindow := anInspectWindow;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspector.AddObject(theObject: TObject);

    VAR
        classId:            ObjClassID;
        theObjectList:        TObjectList;

    PROCEDURE ResetObjListView(aWindow: TInspectWindow);

        VAR
            objListView:        TObjListView;

        BEGIN
        objListView := aWindow.fObjListView;
        IF objListView.fObjectList = theObjectList THEN
            objListView.InsertItem(objListView.fNumberOfItems + 1);
        END;

    BEGIN
 {Don't attempt to add TObjectList objects.  If we did, then we would
  wind up in an infinite loop attempting to create TObjectLists.}
    IF NOT Member(theObject, TObjectList) THEN
        BEGIN
        GetFocus(pSavedFocus);
        gPrinting := False;
        gDrawingPictScrap := False;
        gDrawingPictScrapView := NIL;
        classId := GetClassID(theObject);
        theObjectList := GetObjectList(classId);
        IF theObjectList = NIL THEN
            theObjectList := AddObjectList(classId);
        theObjectList.AddObject(theObject);
        IF (fWindowList <> NIL) & (fWindowList.GetSize > 0) THEN
            BEGIN
            ForAllWindowsDo(ResetObjListView);
            END;
        SetFocus(pSavedFocus);
        END;
    END;

{---------------------------------------------------------------------------}

FUNCTION TInspector.AddObjectList(classId: ObjClassID): TObjectList;

    VAR
        anObjectList:        TObjectList;
        classListItemNo:    INTEGER;

    PROCEDURE ResetClassListView(aWindow: TInspectWindow);

        BEGIN
        aWindow.InsertClass(classListItemNo);
        END;

    BEGIN
    New(anObjectList);
    FailNIL(anObjectList);
    anObjectList.IObjectList(classId);
    fClassesByID.Insert(anObjectList);
    fClassesByName.Insert(anObjectList);
    classListItemNo := fClassesByName.GetSameItemNo(anObjectList);
    ForAllWindowsDo(ResetClassListView);
    AddObjectList := anObjectList;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspector.DoSetupMenus; OVERRIDE;

    BEGIN
    INHERITED DoSetupMenus;

    Enable(cSaveAs, False);
    Enable(cSaveCopy, False);
    END;

{---------------------------------------------------------------------------}

FUNCTION TInspector.GetObjectList(classId: ObjClassID): TObjectList;

    FUNCTION TestClass(anObjectList: TObjectList): INTEGER;

        BEGIN
        IF classId < anObjectList.fObjClassId THEN
            TestClass := kItemGreaterThanCriteria
        ELSE IF classId > anObjectList.fObjClassId THEN
            TestClass := kItemLessThanCriteria
        ELSE
            TestClass := kItemEqualCriteria;
        END;

    BEGIN
    GetObjectList := TObjectList(fClassesByID.Search(TestClass));
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspector.RemoveObject(theObject: TObject);

    VAR
        theObjectList:        TObjectList;
        index:                INTEGER;

    PROCEDURE CheckWindow(theInspectWindow: TInspectWindow);

        BEGIN
        IF theInspectWindow.fObjectView.fObject = theObject THEN
            theInspectWindow.fObjectView.InstallObject(NIL, 0);
        IF theInspectWindow.fObjListView.fObjectList = theObjectList THEN
            theInspectWindow.fObjListView.DeleteItem(index);
        END;

    BEGIN
    IF (fClassesByID <> NIL) & (NOT Member(theObject, TObjectList)) THEN
        BEGIN
        GetFocus(pSavedFocus);
        gPrinting := False;
        gDrawingPictScrap := False;
        gDrawingPictScrapView := NIL;
        theObjectList := GetObjectList(IntegerHandle(theObject)^^);
        IF theObjectList <> NIL THEN
            BEGIN
            index := theObjectList.GetEqualItemNo(theObject);
            theObjectList.RemoveObject(theObject);
            IF (fWindowList <> NIL) & (fWindowList.GetSize > 0) THEN
                BEGIN
                ForAllWindowsDo(CheckWindow);
                END;
            END;
        SetFocus(pSavedFocus);
        END;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.IRes(itsDocument: TDocument;
                              itsSuperView: TView;
                              VAR itsParams: Ptr); OVERRIDE;

    BEGIN
    fClassListView := NIL;
    fObjListView := NIL;
    fObjectView := NIL;

    INHERITED IRes(itsDocument, itsSuperView, itsParams);

    {$Push} {$H-}
    SetPt(fResizeLimits.topLeft, 151, 142);
    {$Pop}
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.IInspectWindow;

    VAR
        aWMgrWindow:        WindowPtr;
        canResize:            BOOLEAN;
        canClose:            BOOLEAN;
        fi:                 FailInfo;
        aClassListView:     TClassListView;
        anObjListView:        TObjListView;
        anObjectView:        TObjectView;
        aScroller:            TScroller;
        itsLocation:        VPoint;
        itsSize:            VPoint;
        screenRect:         Rect;

    PROCEDURE HandleFailure(error: INTEGER;
                            message: LONGINT);

        BEGIN
        {the wmgrWindow is known to exist}
  {Since aWindow didn't get created, the wmgrWindow won't be
   freed unless we do it here.}

        aWMgrWindow := FreeIfWMgrWindow(aWMgrWindow, TRUE);

        END;

    BEGIN
    fClassListView := NIL;
    fObjListView := NIL;
    fObjectView := NIL;

    aWMgrWindow := NIL;
    aWMgrWindow := gApplication.GetRsrcWindow(NIL, kInspectorWindowType, canResize, canClose);
    {GetRsrcWindow signals Failure}

    CatchFailures(fi, HandleFailure);
    IWindow(pInspector, aWMgrWindow, canResize, canClose, TRUE);
    {$Push} {$H-}
    SetPt(fResizeLimits.topLeft, 151, 142);
    {$Pop}

    fClosesDocument := False;
    fFreeOnClosing := TRUE;

    SetVPt(itsLocation, 0, 0);
    SetVPt(itsSize, 65, 12 * 6);
    New(aClassListView);
    FailNIL(aClassListView);
    aClassListView.IClassListView(SELF, itsLocation, itsSize);
    fClassListView := aClassListView;

    SetVPt(itsLocation, 81, 0);
    SetVPt(itsSize, 200 - 81, 12 * 6);
    New(anObjListView);
    FailNIL(anObjListView);
    anObjListView.IObjListView(SELF, itsLocation, itsSize);
    fObjListView := anObjListView;

    SetVPt(itsLocation, 0, 12 * 6 + 1);
    SetVPt(itsSize, 200, fWMgrWindow^.portRect.bottom - itsLocation.v);
    New(anObjectView);
    FailNIL(anObjectView);
    anObjectView.IObjectView(SELF, itsLocation, itsSize);
    fObjectView := anObjectView;

    SetTarget(anObjectView);                            { !!! }

    fSize := gZeroVPt;                                    { Make sure window gets resized }
    WITH fWMgrWindow^.portRect DO
        Resize(right - left, bottom - top, kDontInvalidate);

    { Use GetMaxIntersectedDevice to Locate our window. }
    IF GetMaxIntersectedDevice(screenRect) = NIL THEN;
    WITH screenRect DO
        BEGIN
        Locate(right - fWMgrWindow^.portRect.right, top + fContRgnInset.v, kDontInvalidate);

        {Adapt height of window to height of screen}
        IF bottom > 342 THEN
            Resize(fWMgrWindow^.portRect.right, Max(252, bottom - 192), kDontInvalidate);
        END;

    Success(fi);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.CloseByUser; OVERRIDE;

    BEGIN
 {Overridden to prevent closing the Inspector document when the last
  inspector window is closed.}
    Close;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.Draw(area: Rect); OVERRIDE;

    BEGIN
    INHERITED Draw(area);

    {Draw horizontal line separating upper views from lower view}
    PenNormal;
    MoveTo(0, fObjectView.fSuperView.fLocation.v - 1);
    Line(fSize.h, 0);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.Fields(PROCEDURE DoToField(fieldName: Str255;
                                                    fieldAddr: Ptr;
                                                    fieldType: INTEGER)); OVERRIDE;

    BEGIN
    DoToField('TInspectWindow', NIL, bClass);
    DoToField('fClassListView', @fClassListView, bObject);
    DoToField('fObjListView', @fObjListView, bObject);
    DoToField('fObjectView', @fObjectView, bObject);
    INHERITED Fields(DoToField);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.Resize(width, height: VCoordinate;
                                invalidate: BOOLEAN); OVERRIDE;

    BEGIN
    INHERITED Resize(width, height, invalidate);

 {Resize the upper-right and bottom view to match the window's
  new size.}
    IF fClassListView <> NIL THEN
        BEGIN
        WITH fClassListView.fSuperView DO
            fClassListView.fSuperView.Resize(BSR(width, 1) - kSBarSizeMinus1, fSize.v, invalidate);
        END;
    IF fObjListView <> NIL THEN
        BEGIN
        fObjListView.fSuperView.Locate(BSR(width, 1) + 1, 0, invalidate);
        WITH fObjListView.fSuperView DO
            fObjListView.fSuperView.Resize(width - fLocation.h - kSBarSizeMinus1, fSize.v,
                                           invalidate);
        END;
    IF fObjectView <> NIL THEN
        BEGIN
        WITH fObjectView.fSuperView DO
            fObjectView.fSuperView.Resize(width - kSBarSizeMinus1, (height -
                                          fObjectView.fSuperView.fLocation.v) - kSBarSizeMinus1,
                                          invalidate);
        END;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.InsertClass(itemNo: INTEGER);

    BEGIN
    IF fClassListView <> NIL THEN
        fClassListView.InsertItem(itemNo);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.SetNumberOfClasses(noOfClasses: INTEGER);

    BEGIN
    IF fClassListView <> NIL THEN
        fClassListView.SetNumberOfItems(noOfClasses);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.SetTitleForDoc(newDocTitle: Str255); OVERRIDE;

    BEGIN
    SetTitle(ConcatNumber('Inspector ', pInspector.fWindowCount));
    END;

{---------------------------------------------------------------------------}

PROCEDURE TInspectWindow.SelectObject(theObject: TObject;
                                      theType: INTEGER);

 {This installs the given object as the selected object of the window,
  making sure that the class list and object list views are in sync.}

    VAR
        objectItemNumber, classItemNumber: INTEGER;
        classId:            ObjClassID;
        anObjectList:        TObjectList;
        anObject:            TObject;

    FUNCTION TestClass(anObjectList: TObjectList): BOOLEAN;

        BEGIN
        classItemNumber := classItemNumber + 1;
        TestClass := anObjectList.fObjClassId = classId;
        END;

    FUNCTION TestObject(anObject: TObject): BOOLEAN;

        BEGIN
        objectItemNumber := objectItemNumber + 1;
        TestObject := anObject = theObject;
        END;

    BEGIN
    IF NOT (ODD(LONGINT(theObject))) THEN                {* check for uninitialized object *}
        BEGIN
        IF theType = bObject THEN
            BEGIN
            {* get the new class *}
            classItemNumber := 0;
            classId := GetClassID(theObject);
            anObjectList := TObjectList(pInspector.fClassesByName.FirstThat(TestClass));
            IF anObjectList <> NIL THEN
                BEGIN
                objectItemNumber := 0;
                anObject := anObjectList.FirstThat(TestObject);
                IF anObject <> NIL THEN
                    BEGIN
                    { turn off the old class and select the new class }
                    fClassListView.ChangeSelection(classItemNumber, TRUE);
                    fClassListView.RevealItem(classItemNumber);
                    { turn off the old item and select the new item }
                    fObjListView.ChangeSelection(objectItemNumber, TRUE);
                    END;
                END
                {$IFC qDebugTheDebugger}
            ELSE
                BEGIN
                ProgramBreak('TInspectWindow.SelectObject: Unable to find class');
                END
                {$ENDC}
            ;
            END

        ELSE IF theType <> 0 THEN
            fObjectView.InstallObject(theObject, theType);
        END;
    END;

{ Based on work by Kurt Shmucker Copyright 1986 by Productivity Products International, Inc.
    Used by permission. }

{---------------------------------------------------------------------------}

PROCEDURE TListView.IRes(itsDocument: TDocument;
                         itsSuperView: TView;
                         VAR itsParams: Ptr); OVERRIDE;

    BEGIN
    INHERITED IRes(itsDocument, itsSuperView, itsParams);

    fCurrentSelection := 0;
    fNumberOfItems := 0;
    SetStyle(pInspectorStyle);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.IListView(itsDocument: TDocument;
                              itsSuperView: TView;
                              itsLocation: VPoint;
                              itsSize: VPoint;
                              itsTextStyle: TextStyle;
                              itsNumberOfItems: INTEGER;
                              itsHSizeDet: SizeDeterminer);

    BEGIN
    IView(itsDocument, itsSuperView, itsLocation, itsSize, itsHSizeDet, sizeVariable);
    fCurrentSelection := 0;                             {No item is initially selected}
    fNumberOfItems := itsNumberOfItems;
    SetStyle(itsTextStyle);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.CalcMinSize(VAR minSize: VPoint); OVERRIDE;

    BEGIN
    INHERITED CalcMinSize(minSize);
    { Set the amount of room needed for that many items }
    minSize.v := IntMultiply(fNumberOfItems, fItemHeight);

    IF fNumberOfItems <> 0 THEN
        minSize.h := Max(600, fSuperView.fSize.h)
    ELSE
        minSize.h := 0;
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.ChangeSelection(index: INTEGER;
                                    highlight: BOOLEAN);

    BEGIN
    IF highlight & Focus & IsVisible THEN
        BEGIN
        DoHighlightSelection(fHLDesired, hlOff);
        fCurrentSelection := index;
        DoHighlightSelection(hlOff, fHLDesired);
        END
    ELSE
        fCurrentSelection := index;
    SelectItem(index);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.DeleteItem(itemNo: INTEGER);

    VAR
        topRect, bottomRect: VRect;

    BEGIN
    IF fCurrentSelection > 0 THEN
        IF itemNo < fCurrentSelection THEN
            fCurrentSelection := fCurrentSelection - 1
        ELSE IF itemNo = fCurrentSelection THEN
            fCurrentSelection := 0;

    fNumberOfItems := fNumberOfItems - 1;
    AdjustSize;

    { Invalidate from the deleted item to the end }
    ItemToVRect(itemNo, topRect);
    ItemToVRect(fNumberOfItems, bottomRect);
    topRect.bottom := bottomRect.bottom;
    InvalidVRect(topRect);
    END;

{--------------------------------------------------------------------------------------------------}

{ Dim highlighting of text by gray XORing is not very readable, so dim highlight a text string
by framing it with a gray rectangle.  (Standard highlighting when the window displaying
the view is active is still to invert - black XORing.)    The state transition diagram is:

                                              hlTo

                      |     OFF      |           DIM          |       ON
           -----------|--------------|--------------------|--------------------
               OFF      |     (NA)     |          Frame       |      Invert
           -----------|--------------|--------------------|--------------------
hlFrom           DIM      |     Frame     |          (NA)          |  Frame and Invert
           -----------|--------------|--------------------|--------------------
               ON      |    Invert     |    Invert and Frame  |       (NA)
           -----------|--------------|-----------------------------------------

Since this matrix is (almost) symmetric, we can add together the hlFrom and hlTo parameters
and take one action for each of the three possible sums.  }

PROCEDURE TListView.DoHighlightSelection(fromHL, toHL: HLState); OVERRIDE;

    VAR
        itemVRect:            VRect;
        r:                    Rect;

    BEGIN
    IF (fCurrentSelection > 0) THEN
        BEGIN
        { Make r be the rectangle to invert }
        ItemToVRect(fCurrentSelection, itemVRect);
        ViewToQDRect(itemVRect, r);

        { Set the pen pattern and mode properly }
        PenPat(black);
        PenMode(patXor);

        IF RectIsVisible(r) THEN                        { only do highlighting if part of the
                                                         rectangle is visible }
            BEGIN
            CASE (fromHL + toHL) OF
                hlOffDim:
                    BEGIN
                    UseSelectionColor;
                    FrameRect(r);
                    END;
                hlOffOn:
                    BEGIN
                    UseSelectionColor;
                    InvertRect(r);
                    END;
                hlDimOn:
                    IF fromHL = hlDim THEN
                        BEGIN
                        UseSelectionColor;
                        FrameRect(r);
                        UseSelectionColor;
                        InvertRect(r);
                        END
                    ELSE
                        BEGIN
                        UseSelectionColor;
                        InvertRect(r);
                        UseSelectionColor;
                        FrameRect(r);
                        END;
            END
            END
        END
    END;

{--------------------------------------------------------------------------------------------------}

FUNCTION TListView.DoMouseCommand(VAR theMouse: Point;
                                  VAR info: EventInfo;
                                  VAR hysteresis: Point): TCommand; OVERRIDE;

    VAR
        index:                INTEGER;
        theVMouse:            VPoint;

    BEGIN
    QDToViewPt(theMouse, theVMouse);
    index := VPointToItem(theVMouse);
    IF (index > 0) & (index <= fNumberOfItems) THEN
        ChangeSelection(index, TRUE);
    DoMouseCommand := NIL;
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.Draw(area: Rect); OVERRIDE;

    VAR
        i, firstItem, lastItem: INTEGER;
        viewArea:            VRect;
        baseVPoint:         VPoint;
        basePoint:            Point;

    BEGIN
    SetPen;
    QDToViewRect(area, viewArea);
    WITH viewArea DO
        BEGIN
        {adjust for QuickDraw geometry}
        bottom := bottom - 1;
        right := right - 1;

        firstItem := top DIV fItemHeight + 1;
        lastItem := Min(fNumberOfItems, bottom DIV fItemHeight + 1);
        END;

    SetVPt(baseVPoint, 4, IntMultiply(firstItem - 1, fItemHeight) + fLineAscent);
    basePoint := ViewToQDPt(baseVPoint);
    FOR i := firstItem TO lastItem DO
        BEGIN
        DrawItem(i, basePoint);
        basePoint.v := basePoint.v + fItemHeight;
        END;

    INHERITED Draw(area);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.DrawItem(itemNumber: INTEGER;
                             basePoint: Point);

    BEGIN
    {Should always be overridden.}
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.Fields(PROCEDURE DoToField(fieldName: Str255;
                                               fieldAddr: Ptr;
                                               fieldType: INTEGER)); OVERRIDE;

    BEGIN
    DoToField('TListView', NIL, bClass);
    DoToField('fCurrentSelection', @fCurrentSelection, bInteger);
    DoToField('fNumberOfItems', @fNumberOfItems, bInteger);
    {$Push} {$H-}
    TextStyleFields('fTextStyle', fTextStyle, DoToField);
    {$Pop}
    DoToField('fItemHeight', @fItemHeight, bInteger);
    DoToField('fLineAscent', @fLineAscent, bInteger);
    INHERITED Fields(DoToField);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.InsertItem(itemNo: INTEGER);

    VAR
        topRect, bottomRect: VRect;

    BEGIN
    IF (fCurrentSelection > 0) & (itemNo <= fCurrentSelection) THEN
        fCurrentSelection := fCurrentSelection + 1;

    fNumberOfItems := fNumberOfItems + 1;
    AdjustSize;

    { Invalidate from the inserted item to the end }
    ItemToVRect(itemNo, topRect);
    ItemToVRect(fNumberOfItems, bottomRect);
    topRect.bottom := bottomRect.bottom;
    InvalidVRect(topRect);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.ItemToVRect(index: INTEGER;
                                VAR itemRect: VRect);

    BEGIN
    GetExtent(itemRect);
    itemRect.top := IntMultiply(index - 1, fItemHeight); { Subtract 1 to get the TOP line }
    itemRect.bottom := itemRect.top + fItemHeight;
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.RevealItem(itemNumber: INTEGER);

    VAR
        howMuch:            Point;
        rectToReveal:        VRect;

    BEGIN
    SetPt(howMuch, 0, fItemHeight);
    ItemToVRect(itemNumber, rectToReveal);
    RevealRect(rectToReveal, howMuch, kRedraw);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.SelectItem(itemNumber: INTEGER);

    BEGIN
    {Can be overridden to do something when an item is selected.}
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.SetNumberOfItems(numberOfItems: INTEGER);

    BEGIN
    IF numberOfItems <> fNumberOfItems THEN
        BEGIN
        fNumberOfItems := numberOfItems;
        AdjustSize;
        END;
    ForceRedraw;
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.SetStyle(itsTextStyle: TextStyle);

    VAR
        aPort:                GrafPort;
        savedPort:            GrafPtr;
        theFontInfo:        FontInfo;

    BEGIN
    fTextStyle := itsTextStyle;

    {Need a temporary port to set up the font, so we can get the font info}
    GetPort(savedPort);
    OpenPort(@aPort);
    SetPen;
    GetFontInfo(theFontInfo);
    WITH theFontInfo DO
        BEGIN
        fItemHeight := ascent + descent + leading;
        fLineAscent := ascent + (leading DIV 2) - 1;
        END;
    SetPort(savedPort);
    ClosePort(@aPort);
    AdjustSize;
    END                                                 {TListView.SetFont} ;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TListView.SetPen;

    VAR
        itsTextStyle:        TextStyle;

    BEGIN
    PenNormal;
    itsTextStyle := fTextStyle;
    SetPortTextStyle(itsTextStyle);
    END;

{--------------------------------------------------------------------------------------------------}

FUNCTION TListView.VPointToItem(thePoint: VPoint): INTEGER;

    BEGIN
    VPointToItem := (thePoint.v DIV fItemHeight) + 1;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TClassListView.IRes(itsDocument: TDocument;
                              itsSuperView: TView;
                              VAR itsParams: Ptr); OVERRIDE;

    BEGIN
    INHERITED IRes(itsDocument, itsSuperView, itsParams);

    GetScroller(TRUE).SetScrollParameters(0, fItemHeight, False, TRUE);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TClassListView.IClassListView(itsWindow: TInspectWindow;
                                        itsLocation: VPoint;
                                        itsSize: VPoint);

    VAR
        aScroller:            TScroller;

    BEGIN
    New(aScroller);
    FailNIL(aScroller);
    aScroller.IScroller(itsWindow, itsLocation, itsSize, sizeFixed, sizeFixed, 0, 1000, False,
                        TRUE);

    itsSize.v := 0;                                     { start off with no items }
    IListView(pInspector, aScroller, gZeroVPt, itsSize, pInspectorStyle, 0, sizeFixed);

    aScroller.SetScrollParameters(0, fItemHeight, False, TRUE);

    fInspectWindow := itsWindow;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TClassListView.DrawItem(itemNumber: INTEGER;
                                  basePoint: Point); OVERRIDE;

    VAR
        className:            MAName;
        aStringPtr:         StringPtr;

    BEGIN
    GetClassNameFromID(TObjectList(pInspector.fClassesByName.At(itemNumber)).fObjClassId,
                       className);
    MoveTo(basePoint.h, basePoint.v);
    aStringPtr := StringPtr(@className);
    DrawString(aStringPtr^);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TClassListView.SelectItem(itemNumber: INTEGER); OVERRIDE;

    VAR
        theObjectList:        TObjectList;

    BEGIN
    IF itemNumber > 0 THEN
        BEGIN
        theObjectList := TObjectList(pInspector.fClassesByName.At(itemNumber));
        IF (fInspectWindow.fObjListView <> NIL) THEN
            fInspectWindow.fObjListView.InstallObjectList(theObjectList)
        ELSE
            fInspectWindow.fObjListView.ChangeSelection(0, TRUE);
        END;

    INHERITED SelectItem(itemNumber);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TClassListView.Fields(PROCEDURE DoToField(fieldName: Str255;
                                                    fieldAddr: Ptr;
                                                    fieldType: INTEGER)); OVERRIDE;

    BEGIN
    DoToField('TClassListView', NIL, bClass);
    DoToField('fInspectWindow', @fInspectWindow, bObject);
    INHERITED Fields(DoToField);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjListView.IRes(itsDocument: TDocument;
                            itsSuperView: TView;
                            VAR itsParams: Ptr); OVERRIDE;

    BEGIN
    INHERITED IRes(itsDocument, itsSuperView, itsParams);

    GetScroller(TRUE).SetScrollParameters(0, fItemHeight, FALSE, TRUE);
    fObjectList := NIL;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjListView.IObjListView(itsWindow: TInspectWindow;
                                    itsLocation: VPoint;
                                    itsSize: VPoint);

    VAR
        aScroller:            TScroller;

    BEGIN
    New(aScroller);
    FailNIL(aScroller);
    aScroller.IScroller(itsWindow, itsLocation, itsSize, sizeRelSuperView, sizeFixed, 0, 1000,
                        kWantHScrollBar, kWantVScrollBar);
    itsSize.v := 0;                                     { Start off with no items }
    IListView(pInspector, aScroller, gZeroVPt, itsSize, pInspectorStyle, 0, sizeRelSuperView);
    aScroller.SetScrollParameters(0, fItemHeight, FALSE, TRUE);
    fInspectWindow := itsWindow;
    fObjectList := NIL;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjListView.DrawItem(itemNumber: INTEGER;
                                basePoint: Point); OVERRIDE;

    VAR
        s1:                 Str255;
        aString:            Str255;
        theObject:            TObject;

    BEGIN
    theObject := fObjectList.At(itemNumber);
    PointerToHex(ORD4(theObject), s1, 6);
    aString := '';
    theObject.GetInspectorName(aString);
    aString := CONCAT(s1, ': ', aString);
    MoveTo(basePoint.h, basePoint.v);
    DrawString(aString);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjListView.SelectItem(itemNumber: INTEGER); OVERRIDE;

    BEGIN
 {Assume that we've gotten here only if the field is one that can
  be selected.}
    IF itemNumber > 0 THEN
        fInspectWindow.fObjectView.InstallObject(fObjectList.At(itemNumber), bObject);

    INHERITED SelectItem(itemNumber);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjListView.Fields(PROCEDURE DoToField(fieldName: Str255;
                                                  fieldAddr: Ptr;
                                                  fieldType: INTEGER)); OVERRIDE;

    BEGIN
    DoToField('TObjListView', NIL, bClass);
    DoToField('fInspectWindow', @fInspectWindow, bObject);
    DoToField('fObjectList', @fObjectList, bObject);
    INHERITED Fields(DoToField);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjListView.InstallObjectList(theObjectList: TObjectList);

    BEGIN
    ChangeSelection(0, TRUE);
    IF fObjectList <> theObjectList THEN
        BEGIN
        fObjectList := theObjectList;
        SetNumberOfItems(theObjectList.GetSize);
        RevealTop(kDontRedraw);
        ForceRedraw;
        END;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.IRes(itsDocument: TDocument;
                           itsSuperView: TView;
                           VAR itsParams: Ptr); OVERRIDE;

    BEGIN
    INHERITED IRes(itsDocument, itsSuperView, itsParams);

    GetScroller(TRUE).SetScrollParameters(kSBarSize, fItemHeight, TRUE, TRUE);
    fObject := NIL;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.IObjectView(itsWindow: TInspectWindow;
                                  itsLocation: VPoint;
                                  itsSize: VPoint);

    VAR
        aScroller:            TScroller;

    BEGIN
    New(aScroller);
    FailNIL(aScroller);
    aScroller.IScroller(itsWindow, itsLocation, itsSize, sizeRelSuperView, sizeRelSuperView, 0,
                        1000, TRUE, TRUE);
    aScroller.fSBarOffsets.bottom := - kSBarSizeMinus1;

    itsSize.v := 0;                                     { start off with no items }
    IListView(pInspector, aScroller, gZeroVPt, itsSize, pInspectorStyle, 0, sizeVariable);
    aScroller.SetScrollParameters(kSBarSize, fItemHeight, TRUE, TRUE);
    fInspectWindow := itsWindow;
    fObject := NIL;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.InspectControlHandle(PROCEDURE
                                           InspectField(fieldName: StringPtr;
                                                        fieldAddr: Ptr;
                                                        fieldType: INTEGER));

    TYPE
 {This is an alias for the Control Manager ControlRecord.  The only
  difference is that this is an unpacked record and contrlVis and
  contrlHilite are combined in the contrlVisandHilite field.
  We must have an unpacked record to pass addresses of its fields.}
        UControlHandle        = ^UControlPtr;
        UControlPtr         = ^UnpackedControl;
        UnpackedControl     = RECORD
            nextControl:        ControlHandle;
            contrlOwner:        WindowPtr;
            contrlRect:         Rect;
            contrlVisandHilite: INTEGER;
            contrlValue:        INTEGER;
            contrlMin:            INTEGER;
            contrlMax:            INTEGER;
            contrlDefProc:        Handle;
            contrlData:         Handle;
            contrlAction:        ProcPtr;
            contrlrfCon:        LONGINT;
            contrlTitle:        Str255;
            END;

    VAR
        theControl:         UControlHandle;
        wasLocked:            BOOLEAN;

    BEGIN
    wasLocked := IsHandleLocked(Handle(theControl));
    LockHandleHigh(Handle(theControl));

    theControl := UControlHandle(fObject);
    WITH theControl^^ DO
        BEGIN
        InspectField(AtStr('nextControl'), @nextControl, bControlHandle);
        InspectField(AtStr('contrlOwner'), @contrlOwner, bWindowPtr);
        InspectField(AtStr('contrlRect'), @contrlRect, bRect);
        InspectField(AtStr('contrlVis'), @contrlVisandHilite, bHighByte);
        InspectField(AtStr('contrlHilite'), @contrlVisandHilite, bLowByte);
        InspectField(AtStr('contrlValue'), @contrlValue, bInteger);
        InspectField(AtStr('contrlMin'), @contrlMin, bInteger);
        InspectField(AtStr('contrlMax'), @contrlMax, bInteger);
        InspectField(AtStr('contrlDefProc'), @contrlDefProc, bHandle);
        InspectField(AtStr('contrlData'), @contrlData, bHandle);
        InspectField(AtStr('contrlrfCon'), @contrlrfCon, bHexLongInt);
        InspectField(AtStr('contrlTitle'), @contrlTitle, bString);
        END;

    IF NOT wasLocked THEN
        HUnlock(Handle(theControl));
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.InspectGrafPtr(PROCEDURE InspectField(fieldName: StringPtr;
                                                            fieldAddr: Ptr;
                                                            fieldType: INTEGER));

    VAR
        thePort:            GrafPtr;
        theCPort:            CGrafPtr;

    BEGIN
    thePort := GrafPtr(fObject);
    theCPort := CGrafPtr(fObject);
    IF (qNeedsColorQD | gConfiguration.hasColorQD) & (BAND(theCPort^.portVersion, $C000) =
       $0000C000) THEN                                   { 2 hi bits. IM V pp. 49-50 }
        WITH theCPort^ DO
            BEGIN
            InspectField(AtStr('device'), @device, bInteger);
            InspectField(AtStr('portPixMap'), @portPixMap, bHandle);
            InspectField(AtStr('portVersion'), @portVersion, bHexInteger);
            InspectField(AtStr('grafVars'), @grafVars, bHandle);
            InspectField(AtStr('chExtra'), @chExtra, bInteger);
            InspectField(AtStr('pnLocHFrac'), @pnLocHFrac, bHexInteger);
            InspectField(AtStr('portRect'), @portRect, bRect);
            InspectField(AtStr('visRgn'), @visRgn, bRgnHandle);
            InspectField(AtStr('clipRgn'), @clipRgn, bRgnHandle);
            InspectField(AtStr('bkPixPat'), @bkPixPat, bHandle);
            InspectField(AtStr('rgbFgColor'), @rgbFgColor, bRGBColor);
            InspectField(AtStr('rgbBkColor'), @rgbBkColor, bRGBColor);
            InspectField(AtStr('pnLoc'), @pnLoc, bPoint);
            InspectField(AtStr('pnSize'), @pnSize, bPoint);
            InspectField(AtStr('pnMode'), @pnMode, bInteger);
            InspectField(AtStr('pnPixPat'), @pnPixPat, bHandle);
            InspectField(AtStr('fillPixPat'), @fillPixPat, bHandle);
            END
    ELSE
        WITH thePort^ DO
            BEGIN
            InspectField(AtStr('device'), @device, bInteger);
            InspectField(AtStr('portBits.baseAddr'), @portBits.baseAddr, bPointer);
            InspectField(AtStr('portBits.rowBytes'), @portBits.rowBytes, bInteger);
            InspectField(AtStr('portBits.bounds'), @portBits.bounds, bRect);
            InspectField(AtStr('portRect'), @portRect, bRect);
            InspectField(AtStr('visRgn'), @visRgn, bRgnHandle);
            InspectField(AtStr('clipRgn'), @clipRgn, bRgnHandle);
            InspectField(AtStr('bkPat'), @bkPat, bPattern);
            InspectField(AtStr('fillPat'), @fillPat, bPattern);
            InspectField(AtStr('pnLoc'), @pnLoc, bPoint);
            InspectField(AtStr('pnSize'), @pnSize, bPoint);
            InspectField(AtStr('pnMode'), @pnMode, bInteger);
            InspectField(AtStr('pnPat'), @pnPat, bPattern);
            END;
    {The rest of the fields are common to both GrafPorts and CGrafPorts}
    WITH thePort^ DO
        BEGIN
        InspectField(AtStr('pnVis'), @pnVis, bInteger);
        InspectField(AtStr('txFont'), @txFont, bInteger);
        InspectField(AtStr('txFace'), @txFace, bHexInteger);
        InspectField(AtStr('txMode'), @txMode, bInteger);
        InspectField(AtStr('txSize'), @txSize, bInteger);
        InspectField(AtStr('spExtra'), @spExtra, bFixed);
        InspectField(AtStr('fgColor'), @fgColor, bLongInt);
        InspectField(AtStr('bkColor'), @bkColor, bLongInt);
        InspectField(AtStr('colrBit'), @colrBit, bInteger);
        InspectField(AtStr('patStretch'), @patStretch, bInteger);
        InspectField(AtStr('picSave'), @picSave, bHandle);
        InspectField(AtStr('rgnSave'), @rgnSave, bHandle);
        InspectField(AtStr('polySave'), @polySave, bHandle);
        InspectField(AtStr('grafProcs'), @grafProcs, bPointer);
        END;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.InspectRgnHandle(PROCEDURE InspectField(fieldName: StringPtr;
                                                              fieldAddr: Ptr;
                                                              fieldType: INTEGER));

    VAR
        theRgn:             RgnHandle;
        wasLocked:            BOOLEAN;

    BEGIN
    wasLocked := IsHandleLocked(Handle(theRgn));
    LockHandleHigh(Handle(theRgn));

    theRgn := RgnHandle(fObject);
    WITH theRgn^^ DO
        BEGIN
        InspectField(AtStr('rgnSize'), @rgnSize, bInteger);
        InspectField(AtStr('rgnBBox'), @rgnBBox, bRect);
        END;

    IF NOT wasLocked THEN
        HUnlock(Handle(theRgn));
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.InspectHandle(PROCEDURE InspectField(fieldName: StringPtr;
                                                           fieldAddr: Ptr;
                                                           fieldType: INTEGER));

    VAR
        theHandle:            Handle;

    PROCEDURE ShowMemory(startAddress, numBytes: LONGINT);

        VAR
            i:                    INTEGER;
            addr, lineAddr:     LONGINT;
            numeric:            STRING[40];
            ascii:                STRING[16];
            numPos:             INTEGER;
            ascPos:             INTEGER;
            decNumber:            LONGINT;
            chCode:             INTEGER;
            j:                    INTEGER;

{--------------------------------------------------------------------------------------------------}

        PROCEDURE BlankLine;

            CONST
                k8Spaces            = '        ';

            BEGIN
            ascii := CONCAT(k8Spaces, k8Spaces);
            numeric := CONCAT(ascii, ascii, k8Spaces);
            numPos := 0;
            ascPos := 0;
            END;

{--------------------------------------------------------------------------------------------------}

        PROCEDURE PrintLine;

            VAR
                aStr:                Str255;
                tempString:         String8;

            BEGIN
            LIntToHex(lineAddr, tempString, 8);
            aStr := CONCAT('$', tempString, ': ', numeric, '  ', ascii);
            InspectField(AtStr(''), @aStr, bInternalString);

            END;

        BEGIN
        IF ODD(startAddress) THEN
            InspectField(AtStr('Odd Address'), NIL, bTitle)
        ELSE IF numBytes > 0 THEN
            BEGIN
            BlankLine;

            FOR i := 0 TO (numBytes - 1) DIV 2 DO
                BEGIN
                addr := startAddress + i + i;

                IF (i MOD 8) = 0 THEN
                    BEGIN
                    IF i > 0 THEN
                        BEGIN
                        PrintLine;
                        BlankLine;
                        END;
                    lineAddr := addr;                    { save the address for printline to use }
                    END;

                decNumber := PInteger(addr)^;
                FOR j := 4 DOWNTO 1 DO
                    BEGIN
                    numeric[numPos + j] := kHexDigits[BAND(decNumber, 15) + 1];
                    decNumber := BSR(decNumber, 4);
                    END;

                decNumber := PInteger(addr)^;
                FOR j := 2 DOWNTO 1 DO
                    BEGIN
                    chCode := BAND(decNumber, 255);
                    IF (chCode < $20) | (chCode > $D8) | (chCode = $7F) THEN { control, unassigned,
                           or DEL }
                        chCode := ord('•');
                    ascii[ascPos + j] := CHR(chCode);
                    decNumber := BSR(decNumber, 8);
                    END;

                numPos := numPos + 5;
                ascPos := ascPos + 2;
                END;

            PrintLine;
            END;
        END;

    BEGIN
    theHandle := Handle(fObject);
    ShowMemory(StripLong(theHandle^), GetHandleSize(theHandle));
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.InspectTEHandle(PROCEDURE InspectField(fieldName: StringPtr;
                                                             fieldAddr: Ptr;
                                                             fieldType: INTEGER));

    VAR
        hTE:                TEHandle;
        wasLocked:            BOOLEAN;

    BEGIN
    wasLocked := IsHandleLocked(Handle(hTE));
    LockHandleHigh(Handle(hTE));

    hTE := TEHandle(fObject);
    WITH hTE^^ DO
        BEGIN
        InspectField(AtStr('destRect'), @destRect, bRect);
        InspectField(AtStr('viewRect'), @viewRect, bRect);
        InspectField(AtStr('selRect'), @selRect, bRect);
        InspectField(AtStr('lineHeight'), @lineHeight, bInteger);
        InspectField(AtStr('fontAscent'), @fontAscent, bInteger);
        InspectField(AtStr('selPoint'), @selPoint, bPoint);
        InspectField(AtStr('selStart'), @selStart, bInteger);
        InspectField(AtStr('selEnd'), @selEnd, bInteger);
        InspectField(AtStr('active'), @active, bInteger);
        InspectField(AtStr('wordBreak'), @wordBreak, bPointer);
        InspectField(AtStr('clikLoop'), @clikLoop, bPointer);
        InspectField(AtStr('clickTime'), @clickTime, bLongInt);
        InspectField(AtStr('clickLoc'), @clickLoc, bInteger);
        InspectField(AtStr('caretTime'), @caretTime, bLongInt);
        InspectField(AtStr('caretState'), @caretState, bInteger);
        InspectField(AtStr('just'), @just, bInteger);
        InspectField(AtStr('teLength'), @teLength, bInteger);
        InspectField(AtStr('hText'), @hText, bHandle);
        InspectField(AtStr('recalBack'), @recalBack, bInteger);
        InspectField(AtStr('recalLines'), @recalLines, bInteger);
        InspectField(AtStr('clikStuff'), @clikStuff, bHexInteger);
        InspectField(AtStr('crOnly'), @crOnly, bInteger);
  {If txSize is -1 then the txFont and txFace fields are replaced
   by a handle to a style record.  See Inside Mac Vol. 5.}
        IF txSize = - 1 THEN
            InspectField(AtStr('txFont,txFace'), @txFont, bHandle)
        ELSE
            BEGIN
            InspectField(AtStr('txFont'), @txFont, bInteger);
            InspectField(AtStr('txFace'), @txFace, bStyle);
            END;
        InspectField(AtStr('txMode'), @txMode, bInteger);
        InspectField(AtStr('txSize'), @txSize, bInteger);
        InspectField(AtStr('inPort'), @inPort, bGrafPtr);
        InspectField(AtStr('highHook'), @highHook, bPointer);
        InspectField(AtStr('caretHook'), @caretHook, bPointer);
        InspectField(AtStr('nLines'), @nLines, bInteger);
        END;

    IF NOT wasLocked THEN
        HUnlock(Handle(hTE));
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.InspectWindowPtr(PROCEDURE InspectField(fieldName: StringPtr;
                                                              fieldAddr: Ptr;
                                                              fieldType: INTEGER));

    VAR
        theWindow:            WindowPeek;

    BEGIN
    InspectGrafPtr(InspectField);
    theWindow := WindowPeek(fObject);
    WITH theWindow^ DO
        BEGIN
        InspectField(AtStr('windowKind'), @windowKind, bInteger);
        InspectField(AtStr('visible'), @visible, bBoolean);
        InspectField(AtStr('hilited'), @hilited, bBoolean);
        InspectField(AtStr('goAwayFlag'), @goAwayFlag, bBoolean);
        InspectField(AtStr('spareFlag'), @spareFlag, bBoolean);
        InspectField(AtStr('strucRgn'), @strucRgn, bRgnHandle);
        InspectField(AtStr('contRgn'), @contRgn, bRgnHandle);
        InspectField(AtStr('updateRgn'), @updateRgn, bRgnHandle);
        InspectField(AtStr('windowDefProc'), @windowDefProc, bHandle);
        InspectField(AtStr('dataHandle'), @dataHandle, bHandle);
        InspectField(AtStr('titleHandle'), @titleHandle, bHandle);
        InspectField(AtStr('titleWidth'), @titleWidth, bInteger);
        InspectField(AtStr('controlList'), @controlList, bControlHandle);
        InspectField(AtStr('nextWindow'), @nextWindow, bWindowPtr);
        InspectField(AtStr('windowPic'), @windowPic, bHandle);
        InspectField(AtStr('refCon'), @refCon, bHexLongInt);
        END;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.ChangeSelection(index: INTEGER;
                                      highlight: BOOLEAN); OVERRIDE;

    BEGIN
    SelectField(index, fInspectWindow);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.SelectField(index: INTEGER;
                                  inspectWindow: TInspectWindow);

    VAR
        fieldNo:            INTEGER;

    FUNCTION TestField(fieldName: StringPtr;
                       fieldAddr: Ptr;
                       fieldType: INTEGER): BOOLEAN;

        BEGIN
        fieldNo := fieldNo + 1;
        IF fieldNo = index THEN
            BEGIN
            CASE fieldType OF
                bObject:
                    IF IsObject(TObjectPtr(fieldAddr)^) THEN
                        inspectWindow.SelectObject(TObjectPtr(fieldAddr)^, fieldType);
                bGrafPtr, bWindowPtr, bTEHandle, bControlHandle, bRgnHandle, bHandle:
                    BEGIN
                    IF Handle(fieldAddr)^ <> NIL THEN
                        inspectWindow.SelectObject(TObjectPtr(fieldAddr)^, fieldType);
                    END;
            END;
            TestField := TRUE;
            END
        ELSE
            TestField := False;
        END;

    BEGIN
    IF (index > 0) & (index <= fNumberOfItems) THEN
        BEGIN
        fieldNo := 1;                                    { Skip title line }
        LockObject;
        FirstFieldThat(TestField);
        UnlockObject;
        END;
    END;

{--------------------------------------------------------------------------------------------------}

FUNCTION TObjectView.DoMouseCommand(VAR theMouse: Point;
                                    VAR info: EventInfo;
                                    VAR hysteresis: Point): TCommand; OVERRIDE;

    VAR
        index:                INTEGER;
        theVMouse:            VPoint;
        newInspectWindow:    TInspectWindow;
        wasAddNewObjectsToInspector: BOOLEAN;

    BEGIN
    IF info.theOptionKey THEN
        BEGIN
        QDToViewPt(theMouse, theVMouse);
        index := VPointToItem(theVMouse);
        IF (index > 0) & (index <= fNumberOfItems) THEN
            BEGIN
            {$IFC NOT qDebugTheDebugger}
            wasAddNewObjectsToInspector := AddNewObjectsToInspector(False);
            {$ENDC}
            newInspectWindow := pInspector.MakeWindow;
            {$IFC NOT qDebugTheDebugger}
            wasAddNewObjectsToInspector := AddNewObjectsToInspector(wasAddNewObjectsToInspector);
            {$ENDC}

            SelectField(index, newInspectWindow);
            newInspectWindow.Open;
            END;
        DoMouseCommand := NIL;
        END
    ELSE
        DoMouseCommand := INHERITED DoMouseCommand(theMouse, info, hysteresis);
    END;

{--------------------------------------------------------------------------------------------------}

PROCEDURE TObjectView.Draw(area: Rect); OVERRIDE;

    VAR
        fieldNo, firstField, lastField: INTEGER;
        viewArea:            VRect;
        baseVPoint:         VPoint;
        basePoint:            Point;
        aString:            Str255;

    PROCEDURE FitString(VAR theString: Str255;
                        maxWidth: INTEGER);
    { Truncates theString to fit in maxWidth pixels }

        VAR
            currWidth:            INTEGER;
            noOfChars:            INTEGER;

        BEGIN
        IF StringWidth(theString) > maxWidth THEN
            BEGIN
            currWidth := CharWidth('…');
            noOfChars := 0;
            REPEAT
                noOfChars := noOfChars + 1;
                currWidth := currWidth + CharWidth(theString[noOfChars]);
            UNTIL currWidth > maxWidth;

            {$Push} {$R-}
            theString[0] := CHR(noOfChars);             { Set length of theString }
            {$Pop}
            theString[noOfChars] := '…';
            END;
        END;

    PROCEDURE GetTitle(VAR aString: Str255);

        VAR
            typeName:            Str255;
            aStringPtr:         MANamePtr;

        BEGIN
        CASE fType OF
            bObject:
                BEGIN
                aStringPtr := MANamePtr(@typeName);
                fObject.GetClassName(aStringPtr^);
                END;
            bGrafPtr:
                typeName := 'GrafPtr:';
            bWindowPtr:
                typeName := 'WindowPtr:';
            bControlHandle:
                typeName := 'ControlHandle:';
            bRgnHandle:
                typeName := 'RgnHandle:';
            bTEHandle:
                typeName := 'TEHandle:';
            bHandle:
                typeName := 'Handle:';
        END;
        PointerToHex(ORD4(fObject), aString, 6);
        aString := CONCAT(typeName, '  ', aString);
        IF fType = bObject THEN
            BEGIN
            typeName := '';
            fObject.GetInspectorName(typeName);
            aString := CONCAT(aString, '  ', typeName);
            END;
        END;

    FUNCTION DrawField(fieldName: StringPtr;
                       fieldAddr: Ptr;
                       fieldType: INTEGER): BOOLEAN;

        PROCEDURE DrawObject(theObject: TObject);

            VAR
                s1:                 Str255;
                aString:            Str255;
                aStringPtr:         MANamePtr;

            BEGIN
            { $xxxxx: ClassName Inspectorname }
            PointerToHex(ORD4(theObject), s1, 6);

            aStringPtr := MANamePtr(@aString);
            theObject.GetClassName(aStringPtr^);
            s1 := CONCAT(s1, ': ', aString);

            aString := '';
            theObject.GetInspectorName(aString);
            s1 := CONCAT(s1, ' ', aString);
            DrawString(s1);
            END;

        BEGIN
        DrawField := False;
        fieldNo := fieldNo + 1;
        IF fieldNo >= firstField THEN
            BEGIN
            IF fieldNo > lastField THEN
                BEGIN
                DrawField := TRUE;
                END
            ELSE
                BEGIN

                IF fieldType = bInternalString THEN
                    BEGIN
                    MoveTo(4, basePoint.v);
                    DrawString(StringPtr(fieldAddr)^);
                    END
                ELSE
                    BEGIN
                    IF fieldType = bClass THEN
                        BEGIN
                        aString := fieldName^;
                        TextFace([underline]);
                        END
                    ELSE
                        BEGIN
                        aString := CONCAT('   ', fieldName^, ': ');
                        FitString(aString, Max(94, BSR(fSuperView.fSize.h, 1)));
                        END;

                    MoveTo(4, basePoint.v);
                    DrawString(aString);
                    TextFace([]);

                    IF fieldType <> bClass THEN
                        FieldToString(fieldAddr, fieldType, aString)
                    ELSE
                        aString := '';

                    CASE fieldType OF
                        bObject, bGrafPtr, bWindowPtr, bControlHandle, bRgnHandle, bTEHandle,
                        bHandle:
                            IF Handle(fieldAddr)^ <> NIL THEN
                                TextFace([bold]);
                    END;

                    MoveTo(Max(100, BSR(fSuperView.fSize.h, 1) + 4), basePoint.v);
                    IF (fieldType = bObject) & IsObject(TObjectPtr(fieldAddr)^) THEN
                        DrawObject(TObjectPtr(fieldAddr)^)
                    ELSE
                        DrawString(aString);
                    END;
                TextFace([]);
                basePoint.v := basePoint.v + fItemHeight;
                END;
            END;
        END;

    BEGIN
    IF fObject <> NIL THEN
        BEGIN
        SetPen;
        QDToViewRect(area, viewArea);
        WITH viewArea DO
            BEGIN
            {adjust for QuickDraw geometry}
            bottom := bottom - 1;
            right := right - 1;

            firstField := top DIV fItemHeight + 1;
            lastField := Min(fNumberOfItems, bottom DIV fItemHeight + 1);
            END;

        SetVPt(baseVPoint, 4, IntMultiply(firstField - 1, fItemHeight) + fLineAscent);
        basePoint := ViewToQDPt(baseVPoint);

        IF firstField = 1 THEN
            BEGIN
            GetTitle(aString);
            MoveTo(basePoint.h, basePoint.v);
            DrawString(aString);
            basePoint.v := basePoint.v + fItemHeight;
            END;

        fieldNo := 1;                                    { Skip title line }
        LockObject;
        FirstFieldThat(DrawField);
        UnlockObject;
        END;

    INHERITED Draw(area);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.SuperViewChangedSize(delta: VPoint;
                                     invalidate: BOOLEAN);

    BEGIN
    IF invalidate THEN
        ForceRedraw;
    INHERITED SuperViewChangedSize(delta, invalidate);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.Resize(width, height: VCoordinate;
                             invalidate: BOOLEAN); OVERRIDE;

    BEGIN
    IF invalidate & ((fSize.h <> width) | (fSize.v <> height)) THEN
        ForceRedraw;
    INHERITED Resize(width, height, invalidate);
    END;

{---------------------------------------------------------------------------}
PROCEDURE TObjectView.FirstFieldThat(FUNCTION TestField(fieldName: StringPtr;
                                                        fieldAddr: Ptr;
                                                        fieldType: INTEGER): BOOLEAN);

    LABEL 1000;

    VAR
        oldState:            BOOLEAN;
        fi:                 FailInfo;

    PROCEDURE HandleFailure(error: INTEGER;
                            message: LONGINT);

        BEGIN
        IF error = 0 THEN
            GOTO 1000
        ELSE                                            { someone else signalled it, just let it
                                                         propagate. }
            BEGIN
            {$IFC qDebug}
            gIntenseDebugging := oldState;
            {$EndC}
            END;
        END;

    PROCEDURE DoToField(fieldName: StringPtr;
                        fieldAddr: Ptr;
                        fieldType: INTEGER);

        BEGIN
        IF TestField(fieldName, fieldAddr, fieldType) THEN
            Failure(0, 0);                                { this is kinder to .Fields methods that
                                                         would quiver when a simple exit would yank
                                                         the rug out from under them }
        END;

    PROCEDURE DoToObjectField(fieldName: Str255;
                        fieldAddr: Ptr;
                        fieldType: INTEGER);
        { The Str255 datatype is required to match the fieldName parameter that the procedure
        parameter to fields methods requires.  In some future version of MacApp it would be nice
        to switch .Fields methods to take StringPtrs or maybe to just backend this proc with a
        procedure that takes StringPtrs but trick the compiler into taking it.  Remember that
        C++ users also get to suffer with whatever ultimate solution is chosen. }

        BEGIN
        IF TestField(@fieldName, fieldAddr, fieldType) THEN
            Failure(0, 0);                                { this is kinder to .Fields methods that
                                                         would quiver when a simple exit would yank
                                                         the rug out from under them }
        END;

    BEGIN
    {$IFC qDebug}
    oldState := gIntenseDebugging;
    gIntenseDebugging := False;                         { Suppress printing of info from failure
                                                         signals }
    {$EndC}

    CatchFailures(fi, HandleFailure);
    CASE fType OF
        bObject:
            fObject.Fields(DoToObjectField);
        bGrafPtr:
            InspectGrafPtr(DoToField);
        bWindowPtr:
            InspectWindowPtr(DoToField);
        bControlHandle:
            InspectControlHandle(DoToField);
        bRgnHandle:
            InspectRgnHandle(DoToField);
        bTEHandle:
            InspectTEHandle(DoToField);
        bHandle:
            InspectHandle(DoToField);
    END;
    Success(fi);

1000:
    {$IFC qDebug}
    gIntenseDebugging := oldState;
    {$EndC}

    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.Fields(PROCEDURE DoToField(fieldName: Str255;
                                                 fieldAddr: Ptr;
                                                 fieldType: INTEGER)); OVERRIDE;

    BEGIN
    DoToField('TObjectView', NIL, bClass);
    DoToField('fInspectWindow', @fInspectWindow, bObject);
    DoToField('fObject', @fObject, bObject);
    DoToField('fType', @fType, bInteger);
    DoToField('fLockState', @fLockState, bBoolean);

    INHERITED Fields(DoToField);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.InstallObject(theObject: TObject;
                                    theObjectType: INTEGER);

    VAR
        noOfFields:         INTEGER;

    FUNCTION CountField(fieldName: StringPtr;
                        fieldAddr: Ptr;
                        fieldType: INTEGER): BOOLEAN;

        BEGIN
        CountField := False;
        noOfFields := noOfFields + 1;
        END;

    BEGIN
    fObject := theObject;
    fType := theObjectType;
    noOfFields := 1;                                    { Includes 1 line for title }
    IF theObject <> NIL THEN
        BEGIN
        LockObject;
        FirstFieldThat(CountField);
        UnlockObject;
        END;
    SetNumberOfItems(noOfFields);
    RevealTop(kDontRedraw);
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.LockObject;

    BEGIN
    IF fType = bObject THEN
        fLockState := fObject.Lock(TRUE)
    ELSE IF (fType = bHandle) | (fType = bTEHandle) | (fType = bControlHandle) | (fType =
            bRgnHandle) THEN
        BEGIN
        fLockState := IsHandleLocked(fObject);
        IF NOT fLockState THEN
            HLock(Handle(fObject));
        END;
    END;

{---------------------------------------------------------------------------}

PROCEDURE TObjectView.UnlockObject;

    VAR
        oldState:            BOOLEAN;

    BEGIN
    IF fType = bObject THEN
        oldState := fObject.Lock(fLockState)
    ELSE IF (fType = bHandle) | (fType = bTEHandle) | (fType = bControlHandle) | (fType =
            bRgnHandle) THEN
        IF NOT fLockState THEN
            HUnLock(Handle(fObject));
    END;